/**
 * Created by hanpd on 2017/5/4.
 */

const cryptManager = require('./cryptManager');
import CaHelper from './CaHelper';
import CryptoUtils from '../utils/cryption/CryptoUtils';
import * as umfUtils from "../utils/UmfUtils";
import * as userUtils from '../model/UserUtils';
import * as constants from "../common/Constants";
import RpidUtils from '../utils/RpidUtils';
import DicConstants from '../common/DicConstants';
import UmfLog from '../utils/UmfLog';

export function requestProc(secretData, aesKey) {
    this.secretData = secretData;
    this.aesKey = aesKey;
}

export function processParam(params) {
    _safeTrimFields(params);
    cryptManager.encryptFields(params);
    _addCommonParams(params);
    UmfLog.log("[HTTP] request params:");
    UmfLog.log(params);
}

export function encodeData(reqData) {
    // UmfLog.log("[HTTP] reqData请求参数明文：" + reqData);
    let encBody = cryptManager.encryptBody(reqData);
    // UmfLog.log("[HTTP] aesKey：" + encBody[1]);
    return new requestProc(encBody[0], encBody[1]);
}

/**
 * 转化参数 Object-> a=1&b=2&c=3
 */
export function convertReqData(params) {
    // let result = "";
    // for (let key of Object.keys(params)) {
    //     if (params[key]) {
    //         let valueEncode = encodeURIComponent(params[key]);
    //         if (result) {
    //             result = result + '&' + key + '=' + valueEncode;
    //         } else {
    //             result = key + '=' + params[key];
    //         }
    //         UmfLog.log("[HTTP]:请求参数明文 == " + key + ":" + valueEncode);
    //     }
    // }
    return JSON.stringify(params);
}

function safeChick(rpid, terminalId, loginUserId, loginSession, version) {
    this.rpid = rpid;// 请求流水
    this.terminalId = terminalId;// 终端id
    this.loginUserId = loginUserId;// sessionid
    this.loginSession = loginSession;// sessionid
    this.version = version;// 接口版本号
}

function createSafeChick(params) {
   let {rpid, terminalId, loginUserId, loginSession, version} = params;
   return new safeChick(rpid, terminalId, loginUserId, loginSession, version);
}

function httpHeader(keyId, randomNum, equInfo, ssfe, safeChick, sign) {
    this.keyId = keyId;/* 密钥号（明文）*/
    this.randomNum = randomNum;/*签名随机串（以aes密钥加密）*/
    this.equInfo = equInfo;/*设备信息（不同信息间用“||”间隔，每个信息字段含义需提前约定）*/
    this.ssfe = ssfe;/*用RSA加密后的AES密钥*/
    this.safeChick = safeChick;/*签名（以aes密钥加密）*/
    this.sign = sign;/*存储安全层需要的其他信息，以json格式存储使用AES密钥加密*/
}

export function createHttpHeader(params, aesKey) {
    // keyId：密钥号（明文）
    // ssfe：用RSA加密后的AES密钥
    // equInfo：设备信息（不同信息间用“||”间隔，每个信息字段含义需提前约定）
    // randomNum:签名随机串（以aes密钥加密）
    // sign:签名（以aes密钥加密）
    // safeChick：存储安全层需要的其他信息，以json格式存储使用AES密钥加密，
    // 包含如下内容

    // 设置httpGet的头部参数信息
    //  接口上行报文头信息如下：
    // KeyId：密钥号（明文）
    // let keyId = CaHelper.getTxPulicKeyId(context);
    let keyId = "dummy-keyId"

    // randomNum:签名随机串（以aes密钥加密）
    let randomNum = umfUtils.randomNumber(16);
    let encodeRandomNum = CryptoUtils.aesEncrypt(aesKey, randomNum);

    // SSFE：用RSA加密后的AES密钥
    // SSFE：用RSA加密后的AES密钥 首先对
    // 1.aeskey进行getbyte("GBK")
    // 2.然后用RSA加密得到byte数组 ，
    // 3.将2的byte数组转为16进制的字符串放入 SSFE
    let ssfe = CryptoUtils.rsaEncrypt(aesKey, CaHelper.getTxPublicKey());

    // EquInfo：设备信息（不同信息间用“||”间隔，每个信息字段含义需提前约定）
    // let equInfo = makeDeviceInfo(context);
    // let encodeQeuInfo = cryptoUtils.aesEncrypt(equInfo, aesKey);
    let equInfo = "dummy-equInfo";
    let encodeQeuInfo = CryptoUtils.aesEncrypt(aesKey, equInfo);

    // SafeChick：存储安全层需要的其他信息，以json格式存储使用AES密钥加密，
    // 设置 安全层的sessionid
    // 特别说明，这个值是固定的，如果以后用动态的注释这行就行
    let safeChick = createSafeChick(params);
    let safeChickJson = JSON.stringify(safeChick);
    let encodeSafeChickJson = CryptoUtils.aesEncrypt(aesKey, safeChickJson);

    // 包含如下内容
    // Rpid：请求流水
    // UserId：用户id
    // TermId：终端id
    // SessionId：sessionid
    // Interfaces：请求功能码
    // Version：接口版本号
    // sign:签名（以aes密钥加密）

    // 签名是 keyid + SSFE + EquInfo + SafeChick + randomNum
    let data = keyId + aesKey + equInfo + safeChickJson + randomNum;
    // UmpLog.i(TAG, "签名串sign未计算签名值：" + data);
    let sign = CryptoUtils.sha1Encrypt(data);
    let encodeSing = CryptoUtils.aesEncrypt(aesKey, sign);

    // UmfLog.log("[HTTP]:header参数明文== keyId:" + ":" + keyId);
    // UmfLog.log("[HTTP]:header参数明文== randomNum:" + ":" + randomNum);
    // UmfLog.log("[HTTP]:header参数明文== ssfe:" + ":" + ssfe);
    // UmfLog.log("[HTTP]:header参数明文== equInfo:" + ":" + equInfo);
    // UmfLog.log("[HTTP]:header参数明文== safeChick:" + ":" + safeChickJson);
    // UmfLog.log("[HTTP]:header参数明文== sign:" + ":" + sign);

    return new httpHeader(keyId, encodeRandomNum, encodeQeuInfo, ssfe, encodeSafeChickJson, encodeSing);
}

/**
 * 添加公共参数
 * @param params
 * @private
 */
function _addCommonParams(params) {
    let userInfo = new userUtils.userInfo().get();
    let loginUserId= userInfo.userId;
    let loginAssistId= userInfo.assistId;
    let loginSession = umfUtils.getStorageSync(constants.Keys.SEESION);
    let loginAgentId = userInfo.agentId;

    let permConf = userInfo.permissionConf;
    let rpid = RpidUtils.getRpid();

    //添加公共参数
    params["version"] = "1";
    params["loginUserId"] = loginUserId;
    params["loginAssistId"] = loginAssistId;
    params["loginAgentId"] = loginAgentId;
    params["loginPermConf"] = permConf;
    params["rpid"] = rpid;

    //TODO 现在只有自动登录接口会传loginToken字段，暂时先不赋值待下一期在后台修改
    if (!params["code"]) {
        params["loginToken"] = loginSession;
    }
}

function _safeTrimFields(params) {
        for (let key of Object.keys(params)) {
            //排除不需要trim的字段
            if (DicConstants.ExcludeTrim.constains(key)) {
                continue;
            }
            let value = params[key];
            if (value && typeof value === 'string') {
                params[key] = value.trim();
            }
        }
}